#include "cube.h"

// 立方体顶点定义（8个顶点）
// 坐标系：X右，Y上，Z前
const float Cube::VERTICES[8][3] = {
  { -1, -1, -1 },  // 0: 左下后
  { 1, -1, -1 },   // 1: 右下后
  { 1, 1, -1 },    // 2: 右上后
  { -1, 1, -1 },   // 3: 左上后
  { -1, -1, 1 },   // 4: 左下前
  { 1, -1, 1 },    // 5: 右下前
  { 1, 1, 1 },     // 6: 右上前
  { -1, 1, 1 }     // 7: 左上前
};

// 立方体边的定义（12条边，每条边用两个顶点索引表示）
const int Cube::EDGES[12][2] = {
  // 后面4条边
  { 0, 1 },
  { 1, 2 },
  { 2, 3 },
  { 3, 0 },
  // 前面4条边
  { 4, 5 },
  { 5, 6 },
  { 6, 7 },
  { 7, 4 },
  // 连接前后的4条边
  { 0, 4 },
  { 1, 5 },
  { 2, 6 },
  { 3, 7 }
};

// ========== 初始化函数 ==========

void Cube::init() {
  // 初始化旋转角度
  rotX = 0.3;
  rotY = 0.3;
  rotZ = 0.0;

  // 自动旋转模式
  autoRotate = false;
  autoRotSpeed = 0.02;

  lastUpdateTime = millis();
}

// ========== 绘制函数 ==========

void Cube::drawCube(Screen& screen) {
  // 投影顶点到2D屏幕
  projectVertices();

  // 绘制所有边
  for (int i = 0; i < NUM_EDGES; i++) {
    int v1 = EDGES[i][0];
    int v2 = EDGES[i][1];

    int x1 = (int)projectedVertices[v1][0];
    int y1 = (int)projectedVertices[v1][1];
    int x2 = (int)projectedVertices[v2][0];
    int y2 = (int)projectedVertices[v2][1];

    // 绘制边（使用不同颜色区分前后面）
    uint16_t color;
    if (i < 4) {
      color = TFT_BLUE;  // 后面 - 蓝色
    } else if (i < 8) {
      color = TFT_CYAN;  // 前面 - 青色
    } else {
      color = TFT_GREEN;  // 连接边 - 绿色
    }

    screen.spr.drawLine(x1, y1, x2, y2, color);
  }

  // 绘制顶点（突出显示）
  for (int i = 0; i < NUM_VERTICES; i++) {
    int x = (int)projectedVertices[i][0];
    int y = (int)projectedVertices[i][1];

    // 根据z坐标判断顶点在前还是后，使用不同颜色
    uint16_t pointColor;
    if (i < 4) {
      pointColor = TFT_RED;  // 后面顶点 - 红色
    } else {
      pointColor = TFT_YELLOW;  // 前面顶点 - 黄色
    }

    screen.spr.fillCircle(x, y, 3, pointColor);
  }

  // 绘制坐标轴（可选）
  drawAxes(screen);
}

// 绘制坐标轴辅助线
void Cube::drawAxes(Screen& screen) {
  // X轴 - 红色
  screen.spr.drawLine(CENTER_X, CENTER_Y, CENTER_X + 40, CENTER_Y, TFT_RED);
  screen.spr.drawString("X", CENTER_X + 45, CENTER_Y - 5, 1);

  // Y轴 - 绿色
  screen.spr.drawLine(CENTER_X, CENTER_Y, CENTER_X, CENTER_Y - 40, TFT_GREEN);
  screen.spr.drawString("Y", CENTER_X - 5, CENTER_Y - 50, 1);

  // Z轴 - 蓝色（斜向表示）
  screen.spr.drawLine(CENTER_X, CENTER_Y, CENTER_X - 25, CENTER_Y - 25, TFT_BLUE);
  screen.spr.drawString("Z", CENTER_X - 35, CENTER_Y - 35, 1);
}

// 绘制信息
void Cube::drawInfo(Screen& screen) {
  screen.spr.setTextColor(TFT_WHITE, TFT_BLACK);
  screen.spr.setTextDatum(TL_DATUM);

  // 标题
  screen.spr.drawString("3D 立方体 - 陀螺仪", 5, INFO_Y, 2);

  // 旋转角度信息
  screen.spr.setTextColor(TFT_CYAN, TFT_BLACK);
  screen.spr.drawString("旋转:", 5, INFO_Y + 20, 1);
  screen.spr.setTextColor(TFT_WHITE, TFT_BLACK);

  // X轴旋转
  screen.spr.fillRect(5, INFO_Y + 40, 100, 35, TFT_BLACK);
  screen.spr.drawString("X: " + String(rotX * 57.3, 1) + " 度", 5, INFO_Y + 40, 1);

  // Y轴旋转
  screen.spr.fillRect(5, INFO_Y + 60, 100, 35, TFT_BLACK);
  screen.spr.drawString("Y: " + String(rotY * 57.3, 1) + " 度", 5, INFO_Y + 60, 1);

  // 模式信息
  screen.spr.setTextColor(TFT_YELLOW, TFT_BLACK);
  screen.spr.fillRect(110, INFO_Y + 20, 130, 35, TFT_BLACK);
  if (autoRotate) {
    screen.spr.drawString("模式: 自动", 110, INFO_Y + 20, 1);
  } else {
    screen.spr.drawString("模式: 陀螺仪", 110, INFO_Y + 20, 1);
  }

  // 操作提示
  screen.spr.setTextColor(TFT_GREEN, TFT_BLACK);
  screen.spr.drawString("O: 切换", 130, INFO_Y + 40, 1);
  screen.spr.drawString("X: 退出", 130, INFO_Y + 60, 1);
}

// 绘制帮助信息
void Cube::drawHelp(Screen& screen) {
  screen.spr.setTextColor(TFT_ORANGE, TFT_BLACK);
  screen.spr.setTextDatum(CC_DATUM);

  int helpY = 450;
  screen.spr.drawString("倾斜旋转", CENTER_X, helpY, 2);
  screen.spr.drawString("O: 自动旋转", CENTER_X, helpY + 20, 1);

  screen.spr.setTextDatum(TL_DATUM);
}

// ========== 3D数学计算 ==========

// 角度转弧度
float Cube::degToRad(float degrees) {
  return degrees * PI / 180.0;
}

// 旋转立方体
void Cube::rotateCube(float angleX, float angleY, float angleZ) {
  rotX = angleX;
  rotY = angleY;
  rotZ = angleZ;
}

// 旋转一个点
void Cube::rotatePoint(float& x, float& y, float& z, float rx, float ry, float rz) {
  // 绕X轴旋转
  float y1 = y * cos(rx) - z * sin(rx);
  float z1 = y * sin(rx) + z * cos(rx);
  y = y1;
  z = z1;

  // 绕Y轴旋转
  float x1 = x * cos(ry) + z * sin(ry);
  z1 = -x * sin(ry) + z * cos(ry);
  x = x1;
  z = z1;

  // 绕Z轴旋转
  x1 = x * cos(rz) - y * sin(rz);
  y1 = x * sin(rz) + y * cos(rz);
  x = x1;
  y = y1;
}

// 投影3D顶点到2D屏幕
void Cube::projectVertices() {
  for (int i = 0; i < NUM_VERTICES; i++) {
    // 获取原始顶点坐标
    float x = VERTICES[i][0] * CUBE_SIZE;
    float y = VERTICES[i][1] * CUBE_SIZE;
    float z = VERTICES[i][2] * CUBE_SIZE;

    // 应用旋转
    rotatePoint(x, y, z, rotX, rotY, rotZ);

    // 透视投影（简化版）
    // 距离因子：z值越大（离相机越近），投影越大
    float distance = 300;
    float scale = distance / (distance + z);

    // 投影到2D屏幕
    projectedVertices[i][0] = CENTER_X + x * scale;
    projectedVertices[i][1] = CENTER_Y - y * scale;  // Y轴反转（屏幕坐标系）
  }
}

// ========== 输入处理 ==========

void Cube::handleInput(Keys& keys) {
  keys.kvs_update();

  // O键切换自动旋转模式
  if (keys.o.pressed()) {
    autoRotate = !autoRotate;
    delay(200);  // 防抖
  }

  if (autoRotate) {
    // 自动旋转模式
    rotX += autoRotSpeed;
    rotY += autoRotSpeed * 0.7;
    rotZ += autoRotSpeed * 0.3;
  } else {
    // 陀螺仪控制模式
    // 将陀螺仪数据（-100到100）映射到旋转角度
    // angleX控制绕X轴旋转（俯仰）
    // angleY控制绕Y轴旋转（偏航）

    float gyroX = keys.kvs.angleX / 100.0;  // -1.0 到 1.0
    float gyroY = keys.kvs.angleY / 100.0;

    // 映射到旋转角度（-PI/2 到 PI/2，即-90度到90度）
    rotX = gyroX * PI / 2.0;
    rotY = gyroY * PI / 2.0;

    // Z轴可以使用摇杆控制（可选）
    if (!keys.left.read()) {
      rotZ += 0.05;
    } else if (!keys.right.read()) {
      rotZ -= 0.05;
    }
  }
}

// ========== 主循环 ==========

void Cube::main(Screen& screen, Keys& keys) {
  // 初始化
  init();

  // 清屏
  screen.clearAndLeft();

  // 绘制初始界面
  drawInfo(screen);
  drawHelp(screen);
  screen.drawScreen();

  // 主循环
  while (true) {
    unsigned long currentTime = millis();

    // 处理输入
    handleInput(keys);

    // 检查是否退出
    if (keys.x.pressed()) {
      screen.clearAndCenter();
      return;
    }

    // 更新显示（控制帧率）
    if (currentTime - lastUpdateTime > 30) {  // 约30fps
      // 清除立方体区域
      screen.spr.fillRect(0, 70, TFT_WIDTH, 370, TFT_BLACK);

      // 绘制立方体
      drawCube(screen);

      // 更新信息显示
      drawInfo(screen);

      // 更新屏幕
      screen.drawScreen();

      lastUpdateTime = currentTime;
    }

    delay(10);  // 降低CPU使用率
  }
}
